Portfolio 1 - Cycling Data¶
In [1]:
import pandas as pd
import seaborn as sns
import numpy as np
from matplotlib import pyplot as plt
from datetime import timedelta
from pandas.plotting import scatter_matrix
%matplotlib inline
Analysis of Cycling Data¶
Loading Data¶
The first dataset is an export of my ride data from Strava, an online social
network site for cycling and other sports. This data is a log of every ride since the start of 2018
and contains summary data like the distance and average speed. It was exported using
the script stravaget.py which uses the stravalib module to read data. Some details of
the fields exported by that script can be seen in the documentation for stravalib.
The exported data is a CSV file so that's easy to read, however the date information in the file is recorded in a different timezone (UTC) so we need to do a bit of conversion. In reading the data I'm setting the index of the data frame to be the datetime of the ride.
In [2]:
strava = pd.read_csv('data/strava_export.csv', index_col='date', parse_dates=True)
strava.index = strava.index.tz_convert('Australia/Sydney')
strava.head()
Out[2]:
The second dataset comes from an application called GoldenCheetah which provides some analytics services over ride data. This has some of the same fields but adds a lot of analysis of the power, speed and heart rate data in each ride. This data overlaps with the Strava data but doesn't include all of the same rides.
Again we create an index using the datetime for each ride, this time combining two columns in the data (date and time) and localising to Sydney so that the times match those for the Strava data.
In [3]:
cheetah = pd.read_csv('data/cheetah.csv', skipinitialspace=True)
cheetah.index = pd.to_datetime(cheetah['date'] + ' ' + cheetah['time'])
cheetah.index = cheetah.index.tz_localize('Australia/Sydney')
cheetah.head()
Out[3]:
The GoldenCheetah data contains many many variables (columns) and I won't go into all of them here. Some that are of particular interest for the analysis below are:
Here are definitions of some of the more important fields in the data. Capitalised fields come from the GoldenCheetah data while lowercase_fields come from Strava. There are many cases where fields are duplicated and in this case the values should be the same, although there is room for variation as the algorithm used to calculate them could be different in each case.
- Duration - overall duration of the ride, should be same as elapsed_time
- Time Moving - time spent moving (not resting or waiting at lights), should be the same as moving_time
- Elevation Gain - metres climbed over the ride
- Average Speed - over the ride
- Average Power - average power in watts as measured by a power meter, relates to how much effort is being put in to the ride, should be the same as * average_watts' from Strava
- Nonzero Average Power - same as Average Power but excludes times when power is zero from the average
- Average Heart Rate - should be the same as average_heartrate
- Average Cadence - cadence is the rotations per minute of the pedals
- Average Temp - temperature in the environment as measured by the bike computer (should be same as average_temp)
- VAM - average ascent speed - speed up hills
- Calories (HR) - Calorie expendature as estimated from heart rate data
- 1 sec Peak Power - this and other 'Peak Power' measures give the maximum power output in the ride over this time period. Will be higher for shorter periods. High values in short periods would come from a very 'punchy' ride with sprints for example.
- 1 min Peak Hr - a similar measure relating to Heart Rate
- NP - Normalised Power, a smoothed average power measurement, generally higher than Average Power
- TSS - Training Stress Score, a measure of how hard a ride this was
- device_watts - True if the power (watts) measures were from a power meter, False if they were estimated
- distance - distance travelled in Km
- kudos - likes from other Strava users (social network)
- workout_type - one of 'Race', 'Workout' or 'Ride'
Some of the GoldenCheetah parameters are defined in thier documentation.
Your Tasks¶
Your first task is to combine these two data frames using the join method of Pandas. The goal is to keep only those rows of data
that appear in both data frames so that we have complete data for every row.
In [4]:
table_merge=pd.merge(cheetah, strava, left_index=True, right_index=True, how='inner')
table_merge.head()
Out[4]:
REQUIRED ANALYSIS¶
- Remove rides with no measured power (where device_watts is False) - these are commutes or MTB rides
In [5]:
not_MTB=table_merge[table_merge.device_watts!=False] #remove device_watts = False
not_MTB['Time Moving']=not_MTB['Time Moving']/60 #convert Time Moving to minutes
not_MTB['Duration']=not_MTB['Duration']/60 #convert Time Moving to minutes
#create new DataFrame for data analysis
new_MTB=not_MTB[['Average Heart Rate', 'Average Speed', 'Average Power', 'distance', 'Elevation Gain', 'Time Moving', 'TSS', 'Duration', 'workout_type']]
new_MTB=new_MTB.sort_values(['distance', 'TSS'])
new_MTB.columns = ['Average Heart Rate', 'Average Speed', 'Average Power', 'Distance', 'Elevation Gain', 'Time Moving', 'TSS', 'Duration', 'Workout Type']
- Look at the distributions of some key variables: time, distance, average speed, average power, TSS. Are they normally distributed? Skewed?
- Average Power and Average Speed have left skewed graphs.
- Distance, Duration, and TSS have right skewed graphs.
In [6]:
fig, axes = plt.subplots(1, 2) #two plots side by side
# Distribution Plot (a.k.a. Histogram)
sns.distplot(new_MTB['Average Power'],
ax=axes[0])
sns.distplot(new_MTB['Average Speed'],
ax=axes[1])
Out[6]:
In [7]:
fig, axes = plt.subplots(1, 3) #two plots side by side
# Distribution Plot (a.k.a. Histogram)
sns.distplot(new_MTB['Distance'],
ax=axes[0])
sns.distplot(new_MTB['Duration'],
ax=axes[1])
sns.distplot(new_MTB['TSS'],
ax=axes[2])
Out[7]:
- Explore the relationships between the following variables. Are any of them corrolated with each other (do they vary together in a predictable way)? Can you explain any relationships you observe?
- Average Heart Rate, Average Power and Average Speed are correlated with each other
- Distance, Elevation Gain, Time Moving and TSS are correlated with each other
In [8]:
%run scripts/PearsonValue.py
In [9]:
g = sns.pairplot(new_MTB,
palette = 'husl')
g.map_upper(corr)
plt.show()
In [10]:
sns.pairplot(new_MTB,
vars = ['Average Power', 'Average Speed', 'Average Heart Rate'],
hue = 'Workout Type',
palette = 'husl')
Out[10]:
Average Heart Rate vs Average Power¶
- The higher the Average Heart Rate, the more power the cyclist exerted.
- The cyclist exerts more power in a Race compared to a normal Ride and Workout, which results to higher Average Heart Rate as well.
- Data that has Average Heart Rate or Average power equal to Zero(0) may be cased by device/external errors.
Average Speed vs Average Power¶
- The higher the power, the faster the bike will be. This is supported by Power's formula :
$Power = Force * Velocity$ - As per last analysis in the previous plot( Average Heart Rate VS Average Power ), the cylist exerts more power in Races compared to having a normal Ride and Workout. This also results to having faster speed in Races compared to having a normal Ride and Workout.
- Data that has Average Speed or Average Power equal to Zero(0) may be cased by device/external errors.
Average Heart Rate vs Average Speed¶
- The faster the Speed of the bike the higher the Average Heart Rate will be.
- As per the previous plots, the more power the cyclist exterts the faster the bike will be, and the higher the heart rate he will have.
- The cyclist, same with the previous plot, has higher Average Heart Rate compared in a Race compared to having a normal Ride and Workout
- Data that has Average Heart Rate or Average Speed equal to Zero(0) may be cased by device/external errors.
Observation per Workout Type¶
- as seen in histogram plot, the values of Workout is almost aligned with Ride and Race values.
In [11]:
sns.pairplot(new_MTB,
vars = ['Distance', 'Elevation Gain', 'Time Moving', 'TSS'],
hue = 'Workout Type',
palette = 'husl')
Out[11]:
Distance vs Time Moving¶
- The longer the distance the higher the time moving is, which may be supported by the formula:
$Distance = Speed * Time$ - We can say that distance and moving time are dependent to each other.
- Ride has longer distance range compared to the other 2 categories, that's why its moving time is also higher.
- As seen in the graph, the Race plots has lower value of Time Moving compared to the other two categories. This is because speed and time are indirectly proportional with each other.
Distance vs TSS¶
- The longer the distance the higher the TSS.
$TSS = (Intensity Factor)^2 * Ride Time (hours) * 100$ - Moving Time which we can say dependent to distance, affects TSS.
Elevation Gain vs Distance¶
- For the Ride and Race categories, the longer the Distance travelled by the cyclist the higher his elevation gain is.
- There are some plots with a higher Elevation Gain even though the horizontal distance is the same, these plots have higher vertical distance.
- The horizaontal distance affects the Elevation Gain rate of the cyclist:
$Elavation Gain = \frac{Veritical Distance}{Horizontal Distance} * 100$ - The Workout plot has Zero(0) elevation gain because the cyclist is cycling in stationary position.
Elevation Gain vs Time Moving¶
- For Race and Ride categories, the higher the Elevation Gain rate is, the higher the time moving.
- This is because Vertical Distance and Gravity, slower the acceleration of the cyclist that leads to higher time moving.
$Time = \frac{Distance}{Average Speed}$ - The Workout plot has Zero(0) elevation gain because the cyclist is cycling in stationary position.
Elevation Gain vs TSS¶
- For Race and Ride categories, the higher the Elevation Gain rate is, the higher the TSS.
- The Workout plot has Zero(0) elevation gain because the cyclist is cycling in stationary position.
TSS vs Time Moving¶
- The longer the higher the TSS, the longer the Time Moving period is.
$TSS = (Intensity Factor)^2 * Ride Time (hours) * 100$ - Since the Race category has the shortest Time Moving period, it's TSS is also lower compared to the other two catgories.
- Time Moving is affected by the Speed.
$Time = \frac{Distance}{Average Speed}$
- We want to explore the differences between the three categories:
Race,WorkoutandRide.- Use scatter plots with different colours for each category to explore how these categories differ.
- Use histograms or box plots to visualise the different distributions of a variable for the three categories.
- In both cases, experiment with different variables but only include those that are interesting in your final notebook (if none are interesting, show us a representative example).
In [12]:
# Melt DataFrame
melt_MTB = pd.melt(new_MTB,
id_vars=['Workout Type'],
var_name="Vars")
In [13]:
plt.figure(figsize=(10,6)) #plot size
#box plot
sns.boxplot(x = 'Vars',
y = 'value',
data = melt_MTB,
hue = 'Workout Type',
palette = 'husl')
plt.title('Workout Category')
plt.legend(bbox_to_anchor=(1, 1), loc=2)
plt.xticks(rotation=-10)
Out[13]:
In [14]:
plt.figure(figsize=(10,6))
sns.swarmplot(x = 'Vars',
y = 'value',
data = melt_MTB,
hue = 'Workout Type',
split = True,
palette = 'husl')
plt.legend(bbox_to_anchor=(1, 1), loc=2)
plt.xticks(rotation=-10)
Out[14]:
- Duration and Time Moving have equal values , for categories Race and Workout.
- While Ride has longer Duration compared to Time Moving, which means that in a normal ride, the cyclist takes breaks unlike in the two other categories that ride is continuous(no stops).
- Looking at the three graphs we can observe the relationship of Average Speed, Duration, and Time Moving. The lower the Average Speed is the higher the Duration and Time Moving of the cyclist.
- Though Ride's Elevation Gain is significantly higher than the others, its Average Heart Rate value is smaller compared to Race and Workout . This is due to the Average Speed and Average Power of Race and Workout are higher.
- Though Ride's Time Moving is significantly higher than the other two categories, its distance only has small difference from the other two. This is because its Average Speed is lower compared to the other two categories.
Challenge¶
- What leads to more
kudos? Is there anything to indicate which rides are more popular? Explore the relationship between the main variables and kudos. Show a plot and comment on any relationship you observe.
In [15]:
plt.figure(figsize=(10,6))
sns.barplot(x = 'kudos',
y = 'distance',
data = not_MTB,
hue = 'workout_type',
palette = 'husl',
ci = None)
plt.legend(bbox_to_anchor=(1, 1), loc=2)
plt.xticks(rotation=-10)
Out[15]:
- Longer rides receives more Kudos .
- Race category receives more Kudos compared to the other two, even though its Avearage Distance is shorter .
In [16]:
plt.figure(figsize=(10,6))
sns.barplot(x = 'kudos',
y = 'Average Speed',
data = not_MTB,
hue = 'workout_type',
palette = 'husl',
ci = None)
plt.legend(bbox_to_anchor=(1, 1), loc=2)
plt.xticks(rotation=-10)
Out[16]:
- Race category has higher distance compared to others, but it seems like Average Speed doesn't affect the number of Kudos .
- The Average Speed from different categories are consistent , yet their number of Kudos are varying.
In [17]:
plt.figure(figsize=(10,6))
sns.barplot(x = 'kudos',
y = 'TSS',
data = not_MTB,
hue = 'workout_type',
palette = 'husl',
ci = None)
plt.legend(bbox_to_anchor=(1, 1), loc=2)
plt.xticks(rotation=-10)
Out[17]:
- The Average TSS varies per number of Kudos
- Higher TSS per catergory doesn't guarantee more number of kudos .
- There are TSS which have high values but lesser number of kudos , and others which has lower TSS but higher number of kudos .
Observations:¶
- Category of ride matters to get more Kudos . Races receives the most Kudos, compared to Rides and Workouts.
- The longer the distance the more Kudos is received by the rider.
- As seen in the second and third graphs, Average Speed doesn't really count in receiving more Kudos, same with Average TSS .
Challenge¶
- Generate a plot that summarises the number of km ridden each month over the period of the data. Overlay this with the sum of the Training Stress Score and the average of the Average Speed to generate an overall summary of activity.
In [18]:
%run scripts/CBtwo
#Display DataFrame
df_DT=pd.DataFrame.from_records(Summary, MY)
df_DT=df_DT.dropna()
df_DT.columns=['Total Distance', 'Total TSS', 'Average Speed']
df_DT
Out[18]:
In [19]:
sns.pairplot(df_DT)
Out[19]:
Challenge¶
- Generate a similar graph but one that shows the activity over a given month, with the sum of the values for each day of the month shown. So, if there are two rides on a given day, the graph should show the sum of the distances etc for these rides.
In [20]:
func(5,2019)
Out[20]:
Portfolio 2 - Energy Consumption Data¶
In [1]:
%matplotlib inline
%run scripts/Portfolio2_util.py
import warnings; warnings.simplefilter('ignore')
In [2]:
energydata.head()
Out[2]:
Energy Consumption of Household per month from January to May¶
- no specific pattern observed
In [3]:
energydata.plot.line(x = 'Month',
y = 'Appliances',
figsize=(10,6),
color = '#2E86C1',
title='Appliances Consumption Per Month',
legend = False)
Out[3]:
Energy Consumption of Household in the first week¶
- no specific patter observed
In [4]:
energydata['Date'] = [d.date() for d in energydata.index]
In [5]:
def func(start, end):
range_date = energydata[start:end]
return range_date.plot.line(y = 'Appliances',
figsize=(10,6),
color = '#2E86C1',
title = 'Frequency of Energy Consumption',
legend = False)
func('2016-01-13', '2016-01-19')
Out[5]:
Frequency of Household energy consumption from the Appliance column of the data¶
In [6]:
plt.figure(figsize=(10,6))
sns.distplot(energydata['Appliances'],
kde = False,
bins = 80,
color = '#2E86C1').set_title('Frequency of Energy Consumption')
Out[6]:
In [7]:
plt.figure(figsize=(10,6))
sns.boxplot(x=energydata['Appliances'],
color = '#2E86C1').set_title('Frequency of Energy Consumption')
Out[7]:
In [8]:
%run scripts/PearsonValue.py
Training Set : Pair Plot¶
- Appliances
- Lights
- T1 and RH1 : Temperature and Humidity Kithchen
- T2 and RH2 : Temperature and Humidity Living Room
- T3 and RH3 : Temperature and Humidity Laundry Room
In [9]:
g = sns.pairplot(energydata,
vars = ['Appliances', 'lights', 'T1', 'RH_1', 'T2', 'RH_2', 'T3', 'RH_3'],
palette = 'husl',
diag_kind = 'kde',
diag_kws=dict(shade=True))
g.map_upper(corr)
g.map_lower(sns.regplot, line_kws = {'color':'red'})
plt.show()
Training Set : Pair Plot¶
- Appliances
- T4 and RH4 : Temperature and Humidity Office
- T5 and RH5 : Temperature and Humidity Bathroom
- T6 and RH6 : Temperature and Humidity Outdoor
In [10]:
g = sns.pairplot(energydata,
vars = ['Appliances', 'T4', 'RH_4', 'T5', 'RH_5', 'T6', 'RH_6'],
palette = 'husl',
diag_kind = 'kde',
diag_kws=dict(shade=True))
g.map_upper(corr)
g.map_lower(sns.regplot, line_kws = {'color':'red'})
plt.show()
Training Set : Pair Plot¶
- Appliances
- T_out : Temperature weather station
- Press_mm_hg : Pressure from weather station
- RH_out : Humidity weather station
- Windspeed from weather station
- Visibility from weather station
- Tdewpoint from weather station
- NSM : Number of seconds from midnight
- T6 : Temperature outside the building
In [11]:
g = sns.pairplot(energydata,
vars = ['Appliances', 'T_out', 'Press_mm_hg', 'RH_out', 'Windspeed', 'Visibility', 'Tdewpoint', 'NSM','T6'],
palette = 'husl',
diag_kind = 'kde',
diag_kws=dict(shade=True))
g.map_upper(corr)
g.map_lower(sns.regplot, line_kws = {'color':'red'})
plt.show()
Hourly energy consumption of appliances heat map for four consecutive weeks¶
- no specific pattern observed in daily energy consumption
In [12]:
heatmap_func(2,3,4,5)
RFE & Linear Regression : Normalized Data¶
- Chose 9 features from the dataset columns
In [13]:
RFE_df
Out[13]:
Tally of Mean Sqaured Error and R-Sqaured per Model¶
- Mean Sqaured Error the lower the error value (absolute value) the better the model
- R-Sqaured the higher the value (absolute value) the better the model
In [14]:
stats_df
Out[14]:
Cross Validation per Model, RMSE and R-Sqaured
- As seen in R-Sqaured and RMSE values, SVR is the best model used in this activity. While Random Forest and Gradient Boosting perform the worst
In [15]:
model_list = [linear_model.LinearRegression(),
RandomForestRegressor(n_estimators=20, random_state=0),
GradientBoostingRegressor(n_estimators=20, learning_rate=0.25, max_depth=13, random_state=0),
SVR(kernel = "rbf")]
model_name = ['Linear Regression', 'Random Forest', 'Gradient Boosting', 'SVR']
X = energydata[all_cols]
y = energydata['Appliances']
cv_rec = []
for i in range(4):
model = model_list[i]
r2_cv = cross_val_score(model, X, y, cv=5, scoring = 'r2').mean()
rmse_cv = cross_val_score(model, X, y, cv=5, scoring = 'neg_mean_squared_error').mean()
cv_rec.append((model_name[i], r2_cv, rmse_cv))
cv_df = pd.DataFrame(cv_rec)
cv_df.columns = ['Model', 'R-Squared', 'RMSE']
cv_df.index = cv_df['Model']
cv_df = cv_df.drop('Model',
axis = 1)
In [16]:
plt.figure(figsize=(5,3))
cv_df['R-Squared'].plot(kind = 'barh',
title='R-Squared',
legend = False)
plt.figure(figsize=(5,3))
cv_df['RMSE'].plot(kind = 'barh',
title='RMSE',
legend = False)
Out[16]:
Feature Importance per Model¶
As seen from the graphs below, both models give NSM as the most important variable, but the rest of the varibles differ in importance per model.
In [17]:
X_train_rf = utils.multiclass.type_of_target(X_train.astype('int'))
y_train_rf = utils.multiclass.type_of_target(y_train.astype('int'))
In [18]:
forest = ExtraTreesClassifier(n_estimators=20,
random_state=0)
X = energydata[all_cols]
y = energydata['Appliances']
forest.fit(X, y)
importances = forest.feature_importances_
RF_data = {'Features': all_cols, 'Importance': importances}
RF_df = pd.DataFrame(RF_data)
RF_df = RF_df.sort_values(by = ['Importance'])
plt.figure(figsize=(10,6))
RF_df.plot(kind = 'barh',
x = 'Features',
y = 'Importance',
title='RF Feature Importance',
legend = False)
plt.xlabel('Importance')
Out[18]:
In [19]:
from xgboost import XGBClassifier
from xgboost import plot_importance
model = XGBClassifier()
model.fit(X, y)
plot_importance(model)
plt.figure(figsize=(10,6))
Out[19]:
In [ ]:
Portfolio 3 - Clustering Visualisation¶
K-means clustering is one of the simplest and popular unsupervised learning algorithms. Typically, unsupervised algorithms make inferences from datasets using only input vectors without referring to known, or labelled, outcomes. This notebook illustrates the process of K-means clustering by generating some random clusters of data and then showing the iterations of the algorithm as random cluster means are updated.
We first generate random data around 4 centers.
In [1]:
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
%matplotlib inline
import copy
In [2]:
center_1 = np.array([1,2])
center_2 = np.array([6,6])
center_3 = np.array([9,1])
center_4 = np.array([-5,-1])
# Generate random data and center it to the four centers each with a different variance
np.random.seed(5)
data_1 = np.random.randn(200,2) * 1.5 + center_1
data_2 = np.random.randn(200,2) * 1 + center_2
data_3 = np.random.randn(200,2) * 0.5 + center_3
data_4 = np.random.randn(200,2) * 0.8 + center_4
data = np.concatenate((data_1, data_2, data_3, data_4), axis = 0)
plt.scatter(data[:,0], data[:,1], s=7, c='k')
plt.show()
1. Generate random cluster centres¶
You need to generate four random centres.
This part of portfolio should contain at least:
- The number of clusters
kis set to 4; - Generate random centres via
centres = np.random.randn(k,c)*std + meanwherestdandmeanare the standard deviation and mean of the data.crepresents the number of features in the data. Set the random seed to 6. - Color the generated centers with
green,blue,yellow, andcyan. Set the edgecolors tored.
In [3]:
std = {1: 1.25, 2: 1.75, 3: 1.5, 4: 2}
k = 4
np.random.seed(6)
mean = {i+1: [np.random.randint(1,20), np.random.randint(1,20)]
for i in range(k)}
centres = {i+1: np.random.randn(100,2) * std[i+1] + mean[i+1]
for i in range(k)}
df_centres = pd.DataFrame()
for i in centres.keys():
df_dump = pd.DataFrame(centres[i])
df_centres = df_centres.append(df_dump, ignore_index=True)
df_centres = df_centres.rename(columns = {0: 'x', 1: 'y'})
colmap = {1: 'g', 2: 'b', 3: 'y', 4: 'c'}
for i in mean.keys():
plt.scatter(centres[i][:,0], centres[i][:,1], color = 'k', alpha = 0.2)
plt.scatter(*mean[i], color = colmap[i], edgecolors = 'r')
plt.show()
2. Visualise the clustering results in each iteration¶
You need to implement the process of k-means clustering. Implement each iteration as a seperate cell, assigning each data point to the closest centre, then updating the cluster centres based on the data, then plot the new clusters.
- Cluster the points according to the distance from the assigned centroids.
In [4]:
def clustering(df_centres, mean):
for j in df_centres.iterrows():
for i in mean.keys():
df_centres['distance_from_{}'.format(i)] = (np.sqrt((df_centres['x'] - mean[i][0])**2 +
(df_centres['y'] - mean[i][1])**2))
mean_dist = ['distance_from_{}'.format(i)
for i in mean.keys()]
df_centres['closest'] = df_centres.loc[:, mean_dist].idxmin(axis=1) #outputs data of min distance > index number
df_centres['closest'] = df_centres['closest'].map(lambda x: int(x.lstrip('distance_from_'))) # assigns index number to closest
df_centres['color'] = df_centres['closest'].map(lambda x:colmap[x])
return df_centres
mean_old = copy.deepcopy(mean)
def update(mean):
for i in mean.keys():
mean[i][0] = np.mean(df_centres[df_centres['closest'] == i]['x'])
mean[i][1] = np.mean(df_centres[df_centres['closest'] == i]['y'])
return mean
In [5]:
df_centres = clustering(df_centres, mean)
plt.scatter(df_centres['x'], df_centres['y'], color = df_centres['color'], alpha = 0.2)
for i in centres.keys():
plt.scatter(*mean[i], color = colmap[i], edgecolors = 'r')
plt.show()
- Iterates the calculations of the points, to enhance the positions of the centroid and updates it. Stabilization of the centroid means that the clustering has been successful.
In [6]:
df_mean = pd.DataFrame()
x_diff = 1
y_diff = 1
while x_diff != 0 and y_diff != 0:
mean_old = copy.deepcopy(mean)
mean = update(mean)
mean_dp = pd.DataFrame(mean)
mean_dp = mean_dp.T
mean_dp = mean_dp.rename(columns = {0: 'x', 1: 'y'})
mean_dp['xy'] = mean_dp.apply(lambda x: [x['x'], x['y']], axis=1)
mean_dp = mean_dp.drop(['x', 'y'], axis=1)
mean_dp = mean_dp.T
df_mean = df_mean.append(mean_dp, ignore_index = True)
df_centres = clustering(df_centres, mean)
for i in mean.keys():
x_diff = (mean[i][0] - mean_old[i][0])
y_diff = (mean[i][1] - mean_old[i][1])
plt.scatter(df_centres['x'], df_centres['y'], color = df_centres['color'], alpha = 0.2)
for i in centres.keys():
plt.scatter(*mean[i], color = colmap[i], edgecolors = 'r')
plt.show()
In [7]:
df_mean = df_mean.rename(columns = {1: 'Cluster 1', 2: 'Cluster 2', 3: 'Cluster 3', 4: 'Cluster 4'})
df_mean
Out[7]:
In [ ]: